         Ferris             The Hex Files             
                Programmer at work - part 2 by Ferris 

 Hello all and welcome to the second part of our course for
 budding programmers. Last issue we introduced a few of the
 commands our C64 can understand and this issue I intend to
 bring a few more in to play. LDA and LDX have both been
 covered independently last issue, but they can work together.
 Lets get things off to a start with the first example:

LDX #$00      Set the X register to zero.
LDA #$01      Set the A register as well.
STA $0400,X   Store A to $0400+X.
RTS           Exit.

 If we were to run this a letter A would appear at the top
 left corner of our screen. Nothing exiting so far eh? Well,
 if we were to alter the first command to read LDX #$01 and
 re-run it the results would be slightly different in that the
 A would now be one character to the right. So how does this
 actually work you ask. Well, the first command sets the value
 in the X register and the second sets the accumulator (A
 register) in the same way as before. But the STA command has
 been altered slightly so that instead of just putting the
 contents of A to a set place (in this case memory location
 1,024) it adds the value in X to the location. So if X is 0
 then the A character appears at 1,024 and if it were 40 then
 the A will be one line down because there are forty
 characters a line.

 This is the basics of loops in machine code, but before we
 can introduce them properly we need to first look at another
 facet of machine code. When writing code it is necessary to
 leap back and forth through the program in the same way that
 BASIC can with GOTO's and GOSUB's. Because we have no line
 numbers we need some way of identifying a piece of code to
 jump to which is what labels do. A label is not actually a
 command its a word, but it's like naming a piece of your
 program so that you can then refer to it by that name.
 Classic examples are calling a loop LOOP or your control
 routine READSTICK (for reading the joystick) but just about
 any word that doesn't have an instruction in can be used.
 Labels do have other uses which we will cover later but for
 now I'll leave this definition.

 Time for another example I think, this time showing the use
 of a label and our next two commands. This next example
 would, if executed, put eight A's at the top left of the
 screen:

          LDX #$00       Reset X.
          LDA #$01       Put 1 in A.
LOOP      STA $0400,X    Our first label!
          INX            INcrement X (as before).
          CPX #$08       ComPare X to see if its 8.
          BNE LOOP       Branch if Not Equal to "loop".
          RTS            Stop.

 Why have I confused you and introduced two new commands
 together? Well, lets cover each command in turn. First, CPX
 is short for ComPare X and its job is to compare things to
 the X register (obvious, eh?) In the example above we are
 checking to see if X has the value of #$08 but if we wanted
 to put say nine A's we merely change the command to CPX #$09.
 But when we have done this comparison we need to then do
 something with the results. And this is where Branch if Not
 Equal, or BNE comes in.

 The basic flow of this loop goes like thus. We put a zero in
 X and a one in A (for character 1, which is the A we would
 see on screen). Then we hit the main loop which puts the
 contents of A into location $0400 + X, which is $0400 since X
 is zero. Then we add one to X and compare it to eight to see
 if it's reached the end, if not we branch back to LOOP and
 put another character down at $0400 + X (which is now $0401
 since X is 1). This continues until X does reach eight. When
 this happens the BNE is ignored (after all, it is equal now)
 and we fall through to the end.

 Some of you may be a bit confused by this logic, thinking
 that since we stop when X reaches eight then surely the
 eighth character wouldn't appear on screen because the loop
 would stop, but it makes more sense when you remember that we
 are counting from zero and not one.

 So far we have been examining routines purely in theory but
 I'm sure we are getting to the point where all of you want to
 start seeing results from your code. To this end we have
 included Turbo Assembler on the download page for you to play
 with. Emulator users please note that,due to a problem with
 the emulator, C64S cannot run this program. To start you all
 off I'll just give you the basics of starting it up and we
 will enter the previous example into Turbo and run it to show
 it working. First off you need to load the assembler (the
 filename is "TASM V5.6X /MIC") and when it's done type
 SYS36864. Two lines of text appear at the bottom of the
 screen giving the version number and statistics.

 Because we are now moving into the "real" world of
 programming the listing is slightly different. First tap
 return once and the cursor will move to its start position.
 Now type this:

          *= $0900
          LDX #$00
          LDA #$01
LOOP      STA $0400,X
          INX
          CPX #$08
          BNE LOOP
          RTS

 The difference is the *= $0900 at the top. This is a command
 specific to Turbo Assembler to tell it where we want our code
 to go (in this case $0900 in memory which is 2,304 in
 decimal). Now we want to see our code going so first press
 the back arrow key (at the top left of the keyboard) and the
 cursor will vanish. Press the "3" key to assemble and if all
 has gone well you will see a new page appear giving
 information on our program. The last three lines should read:

 errors: 0
 press `s` to start
 or other key to edit

 and you can press the "S" key. And before you can even see
 the "started" message on screen our little listing has put
 eight "A" characters at the top left of the screen! To get
 back into the editor type SYS36864 again.

 Well, that's the second part over with but before you carry
 on to the next part I'll give you with a little challenge.
 Can you figure out how to change our example to put eleven
 characters on the screen in the listing above and change them
 from "A" to "C"? Why not play with the code and see what you
 can come up with! If you have any questions about this
 article or machine code, drop me an email and I'll see what I
 can do!</BODY

